Package: cdmb
Common Data Model Builder (cdmb)User InterfaceOutputsClassesMetadataAuthorCohortCrosswalksEntitiesVariablesCatalogsRules SetRulesComparison ruleBetweenComparisonNullCheckingRuleInValuesRuleComposedRuleDummyRuleRelationshipsCommon Data ModelData typesOutputsAuthoringHow to contributeReferencesTable of contents generated with markdown-tocCommon Data Model Builder (cdmb)The Common Data Model Builder (cdmb) is a Python library that facilitates building data models for projects with a defined structure. The library offers two ways to generate data models: using code or using a graphical interface. The library facilitates  completing the project's metadata, including the cohort's definition, the entities and the validation rules of the data model. The cdmb assists a user in systematically generating a reproducible folder structure of the research project as a Research Object (RO) easily implemented in as part of a deployable workflow.User InterfaceMain functionalities:One of the functionalities of Common Data Model Builder is to provide the user with a graphical interface to fill in the Common Data Model and export it in a simple way. Follow the following code snippet to access it.Inputs:server_address: a string representing the server address, default value is "localhost"port: a string representing the server port, default value is "8501"Example:fromcdmbimportlaunch_uiserver_address="localhost"port=8000launch_ui(server_address,port)# Open your web browser at http://<server_address>:<port>.# http://localhost:8000Run in DockerAlternatively you can run the graphical interface provided by the Common Data Model Builder directly in a docker container.Use the following code snippet to create the container.dockerpullghcr.io/cienciadedatosysalud/cdmb:latest

dockerrun-d-p127.0.0.1:8501:8501--namecdmb_uighcr.io/cienciadedatosysalud/cdmb:latestOpen your web browser athttp://localhost:8501.OutputsOutputs structure and content is described below including the files and folders that are generated when creating a research project with thecdmbPython library. There are four main folders corresponding to:docs/CDM/cdmb_config.json: Configuration file.cohort_definition_inclusion.csv: csv file that defines the criteria (i.e., codes) for inclusion in a cohort.cohort_definition_exclusion.csv: csv file that defines the criteria (i.e., codes) for exclusion in a cohort.common_datamodel.xlsx: The definition of the common data model in Excel format.entities/: Folder structure where, for each defined entity, the catalogs and the established validation rules are stored.ER.gv, ER.gv.png: an Entity-Relationship Diagram of the entities included in the CDM.synthetic-data/: Folder structure contaning an automatically generated set of 1000 synthetic records per entity included en the CDM.hashed_files_list.json: List of the files generated or used after generating the project with their md5 hash. This file must be kept hidden
and should be used to cross-check with the results obtained from the analysis from the original input files.inputs/data.duckdb: Database that temporarily contains the data entered by the user (synthetic data by default)outputs/(Default directory of all the outputs produced in the project execution)src/analysis-scripts/(directory where the analysis scripts developed by the user are stored)r_report_template.qmd: Quarto document, with an example analysis, showing the interaction with the folder structure and files generated in the project._quarto.yml: File containing the Metadata to execute Quarto documents.check_load-scripts/check_load.py: Script in charge of the mapping between the files introduced by the user (./inputs) and map them to the defined entities (inputs/data.duckdb).
In the loading process, the following checks are performed: Name of the variables match; the format/type of the variables match those established in the configuration.inputs/: Auxiliary folder for the script 'check_load.py'.dqa-scripts/dqa.py: Data Quality Assesment script by default.validation-scripts/validator.py: Script in charge of applying the validation rules to the data.valididator_report.qmd: Quarto document that generates a report in html from the results obtained from 'validator.py'._quarto.yml: File containing metadata to execute Quarto documents.ro-crate-metadata.json: Accessible and practical formal metadata description for use in a wider variety of situations,
from an individual researcher working with a folder of data, to large data-intensive computational research environments. For more information, visitRO-Crate.man_container_deployment.md: From Data Science for Health Services and Policy Research group we provide in the following
GitHub repository, a solution, for the deployment of the generated project. This step is optional.LICENSE.md: Project license (CC BY 4.0 by default).ClassesMetadataMain functionalities:The Metadata class is designed to store and manage metadata information for a research project. It allows for the storage of project information such as project name, version, authors, keywords, description, notes, spatial coverage, and license. The class also provides methods for adding and removing authors, setting and getting values for the various fields, and returning the metadata structure as a dictionary.Methods:__init__: Initializes the Metadata object with the given project, use case, version, funder, url_project, work_package, document, authors, keywords, description, notes, spatial_coverage, and license.add_author: Adds an Author object to the list of authors.pop_author: Removes and returns the last Author object from the list of authors.get_structure: Returns the metadata structure as a dictionary.Varioussettermethods: Set the values of the corresponding fields.Variousgettermethods: Return the values of the corresponding fields.Fields:uuid: A unique identifier for the Metadata object (automatycally generated).project: The name of the project.funder: The name of the funder of the project.url_project: The URL of the project.work_package: The name of the work package.use_case: The name of the use case.document: The name of the document.version_sem: The semantic version of the project.authors: A list of Author objects.keywords: A list of keywords associated with the project.description: A description of the project.notes: Additional notes about the project.spatial_coverage: The spatial coverage of the project.license: The license of the project.Example:fromcdmbimportMetadatametadata=Metadata(project='Test Project',use_case='Use Case')AuthorMain functionalities:The Author class represents the information associated with the author(s), including their name, affiliation, and ORCID identifier. It provides methods to set and get these attributes, as well as a method to retrieve the author's information as a dictionary.Methods:__init__: initializes the Author object with the provided name, affiliation, and ORCID identifiername, affiliation, id getters and setters: allow getting and setting the name, affiliation, and ORCID identifier attributes of the Author objectget_structure: returns the Author object's attributes as a dictionaryFields:name: the name of the authoraffiliation: the affiliation of the authorid: the ORCID identifier of the authorExample:fromcdmbimportAuthorfromcdmbimportMetadataauthor=Author(name='John Doe',affiliation='University of California',id='0000-0000-0000-0001')metadata=Metadata(project='Test Project',use_case='Use Case')metadata.add_author(author)CohortMain functionalities:The Cohort class represents a cohort study and its main functionalities are to store information about the cohort, such as its name, description, inclusion and exclusion criteria, study period, and crosswalks for inclusion and exclusion definitions. It also provides methods to get and set these fields and to get the structure of the cohort.Methods:__init__: initializes the cohort object with its fields and validates their types and lengths.gettersandsetters: provide access to the fields of the cohort object and validate their types and lengths.get_structure: returns a dictionary with the structure of the cohort object, including its fields and the structure of its crosswalks.Fields:name: the name of the cohort.description: the description of the cohort.inclusion_criteria: the inclusion criteria of the cohort.exclusion_criteria: the exclusion criteria of the cohort.beggining_study_period: the beginning of the study period.end_study_period: the end of the study period.cohort_definition_inclusion: the crosswalks for the inclusion definition.cohort_definition_exclusion: the crosswalks for the exclusion definition.Example:fromcdmbimportCohortimportdatetimecohort=Cohort(name='Cohort name',description='Cohort description',inclusion_criteria='Inclusion criteria text',beggining_study_period=datetime.date(2021,1,1),end_study_period=datetime.date(2021,12,31))CrosswalksMain functionalities:The Crosswalks class is a data structure that represents crosswalks. It allows the user to specify a pandas DataFrame, a column name, a nature, and a filename. The class provides methods to get and set the filename, nature, column name, and data. It also provides methods to get the header and structure of the crosswalks.Methods:__init__: initializes the class with optional parameters data, column_name, nature, and filename.get_header: returns the column labels of data.get_structure: returns a dictionary with the filename, nature, and column_name.filename.setter: sets the filename.nature.setter: sets the nature.column_name.setter: sets the column name.data.setter: sets the data.Fields:filename: the name of the file as the crosswalks will be saved.nature: the nature of the crosswalks.column_name: the name of the column used as reference.data: the crosswalks as a pandas DataFrame.Example:importpandasfromcdmbimportCrosswalksfromcdmbimportCohortimportdatetimecrosswalks_df=pandas.DataFrame({'code':['A1','A2','A3'],'name':['Condition 1','Condition 2','Condition 3']})crosswalks=Crosswalks(data=crosswalks_df,column_name='code',nature='Condition',filename='crosswalks.csv')cohort=Cohort(name='Cohort name',description='Cohort description',inclusion_criteria='Inclusion criteria text',beggining_study_period=datetime.date(2021,1,1),end_study_period=datetime.date(2021,12,31),cohort_definition_inclusion=crosswalks)EntitiesMain functionalities:The Entity class represents an entity in a data model and contains information about its variables and rules. It allows for the addition and removal of variables, as well as the creation of rules from expressions. It also provides methods for getting the structure of the entity, its variables, and its rules, as well as for getting catalogs associated with its variables.Methods:__init__: initializes the Entity object with a name, time_varying flag, list of variables, and RuleSet objectadd_variable: adds a Variable object to the list of variablespop_variable: removes and returns the last Variable object in the list of variablesget_variable_by_label: returns the Variable object with the given labelget_catalogs: returns a tuple of dictionaries containing information about catalogs associated with the entity's variablesget_rules_synthetic: returns a list of rules for generating synthetic datadict_to_variables: converts a list of dictionaries to Variable objects and adds them to the list of variablesget_rules_structure: returns a dictionary containing information about the entity's rulesget_structure: returns a dictionary containing information about the entity's structureget_variables_in_order: returns a list of variables in the order specified by the input Variable objectget_tree_structure_rules: returns a Tree object representing the dependencies between the entity's variables based on its rulescreate_rule_from_expression: creates a Rule object from a string expressionFields:uuid: a unique identifier for the entity (automatycally generated)name: the name of the entitytime_varying: a boolean flag indicating whether the entity is time-varyingvariables: a list of Variable objects associated with the entityrules: a RuleSet object containing the rules associated with the entityExample:fromcdmbimportEntityentity=Entity('Entity_name',time_varying=True)VariablesMain functionalities:The Variable class represents a variable in a dataset and contains information about its label, description, format, type, units, requirement level, characteristic, catalog, and other metadata. It allows for setting and getting these attributes and provides methods for getting the structure of the variable.Methods:__init__: initializes a Variable object with the given attributesget_structure: returns a dictionary with the structure of the variablegettersandsettersfor each attribute: allows for getting and setting each attribute of the variableFields:label: the label of the variabledescription: the description of the variablestandard_classification: the standard classification of the variableformat: the format of the variabletype: the type of the variableunits: the units of the variablerequirement_level: the requirement level of the variablecharacteristic: the characteristic of the variablecatalog_bl: a boolean indicating whether the variable has a catalogtransformations_from_origin: the transformations applied to the variable from its originpossible_data_source: the possible data sources for the variableobservations_comments: comments about the observations of the variableexamples: examples of the variablecatalog: the catalog of the variable, if it has oneExample:fromcdmbimportEntityfromcdmbimportVariableentity=Entity('Entity_name',time_varying=True)var=Variable(label='label',description='description',standard_classification='standard classification',format='String',type='Categorical',units='units',requirement_level='Required',characteristic='Observed',catalog_bl=False,transformations_from_origin='transformations from origin',possible_data_source='possible data source',observations_comments='observations comments',examples='test examples',catalog=None)entity.add_variable(var)CatalogsMain functionalities:The Catalog class is a data structure that represents a catalog. It takes a pandas DataFrame, a column name, and a filename as input and provides methods to get and set the column name, filename, and data. It also provides methods to get the header, catalog, and structure of the catalog.Methods:__init__: Initializes the Catalog class with a DataFrame, column name, and filename.get_header: Returns the header of the catalog.get_catalog: Returns a dictionary with the filename, column name, and data of the catalog.get_structure: Returns a dictionary with the column name and filename of the catalog.column_name: Getter and setter for the column name field.filename: Getter and setter for the filename field.data: Getter and setter for the data field.Fields:column_name: Name of the column used as reference.filename: Name of the file as the catalog will be saved.data: DataFrame with the catalog data.Example:fromcdmbimportEntityfromcdmbimportVariablefromcdmbimportCatalogimportpandasaspddf=pd.DataFrame({'A':[1,2],'B':[3,4]})catalog=Catalog(df,'A','test.csv')entity=Entity('Entity_name',time_varying=True)var=Variable(label='label',description='description',standard_classification='standard classification',format='String',type='Categorical',units='units',requirement_level='Required',characteristic='Observed',catalog_bl=False,transformations_from_origin='transformations from origin',possible_data_source='possible data source',observations_comments='observations comments',examples='test examples',catalog=None)var.catalog=catalogentity.add_variable(var)Rules SetMain functionalities:The RuleSet class is responsible for managing a set of rules that can be applied to a dataset. It allows for the creation, modification, and retrieval of rules, as well as the generation of synthetic data based on those rules. The class also provides methods for getting the structure of the rules and for generating example rules based on a list of variables.Methods:__init__: initializes the RuleSet object with a list of rules (if provided) and a description of the syntax for the rules.append_rule: adds a new rule to the list of rules.pop_rule: removes and returns the last rule in the list of rules.rules_for_synthetic_data: generates a set of rules for generating synthetic data based on the current set of rules and a list of variables.get_rules_comparison_between_variables: generates a set of rules for comparing variables in the current set of rules.get_rules_dict: returns a dictionary representation of the current set of rules.get_structure: returns a list of dictionaries representing the structure of the current set of rules.get_rules_structure_example: generates example rules based on a list of variables.Example:fromcdmbimportComparisonRule,BetweenComparison,RuleSet,Variabler1=ComparisonRule(Variable('age',"patient's age"),'>=',18)r2=BetweenComparison(Variable('height',"patient's height"),170,180)rs=RuleSet([r1,r2])RulesComparison ruleMain functionalities:The ComparisonRule class is a subclass of the abstract class Rule and represents a rule that compares a left statement with a right statement using a comparison operator. The main functionalities of this class are:To create a comparison rule with a left statement, a comparison operator, and a right statement.To validate the types of the left statement, the comparison operator, and the right statement.To treat the right statement according to its type and the comparison operator.To generate an expression that represents the comparison rule.To provide information about the comparison rule, such as its name, description, subtype comparison, max value, min value, and variable affected.Methods:__init__: initializes the ComparisonRule object with a left statement, a comparison operator, and a right statement. It validates the types of the left statement, the comparison operator, and the right statement, and treats the right statement according to its type and the comparison operator. It generates an expression that represents the comparison rule, and provides information about the comparison rule, such as its name, description, subtype comparison, max value, min value, and variable affected.get_structure: returns a dictionary with the expression, name, and description of the comparison rule.Example:fromcdmbimportVariablefromcdmbimportComparisonRuleimportdatetime# ComparisonOperators ['<', '<=', '>', '>=', '=', '<>', '!=']left_statement=Variable('age',"patient's age")comparison_operator='>='right_statement=18rule=ComparisonRule(left_statement,comparison_operator,right_statement)# Compare variablesleft_statement=Variable('admission_dt','hospital admission')right_statement=Variable('discharge_dt','hospital discharge')rule2=ComparisonRule(left_statement,'<=',right_statement)# Compare with datesrule3=ComparisonRule(left_statement,'>=',datetime.date(2022,1,1))BetweenComparisonMain functionalities:The BetweenComparison class is a subclass of the Rule abstract class and represents a rule that checks if a variable's value is between two given values. It can handle numerical, date, and datetime values. The rule can be negated to check if the variable's value is not between the two given values.Methods:__init__: Initializes the BetweenComparison object with a variable, two values, and a flag to negate the rule. It checks the types of the inputs and constructs the expression for the rule.get_structure: Returns a dictionary with the expression, name, and description of the rule.Example:fromcdmbimportVariablefromcdmbimportBetweenComparisonimportdatetimevariable=Variable('age',"patient's age")x_value=18y_value=115r1=BetweenComparison(variable,x_value,y_value)# r1 -> age BETWEEN 18 AND 115variable2=Variable('admission_dt','hospital admission')r2=BetweenComparison(variable2,datetime.date(2020,1,1),datetime.date(2021,1,1),negative=True)# r2 -> admission_dt NOT BETWEEN '2020-01-01' AND '2021-01-01'NullCheckingRuleMain functionalities:The NullCheckingRule class is a subclass of the abstract Rule class and represents a rule that checks whether a given variable is null or not null. It takes a Variable object and a boolean value as input and generates a SQL expression that checks whether the variable is null or not null based on the boolean value. This class is used to create rules for data validation and filtering.Methods:__init__: Constructor method that takes a Variable object and a boolean value as input and generates a SQL expression that checks whether the variable is null or not null based on the boolean value.get_structure: Method that returns a dictionary with the expression, name, and description of the rule.Example:fromcdmbimportVariablefromcdmbimportNullCheckingRulevariable_1=Variable('admission_dt','hospital admission')rule=NullCheckingRule(variable_1,negative=True)# rule -> admission_dt IS NOT NULLvariable_2=Variable('discharge_dt','hospital discharge')rule2=NullCheckingRule(variable_2,negative=False)# rule2 -> discharge_dt IS NULLInValuesRuleMain functionalities:The InValuesRule class is a subclass of the abstract Rule class and represents a rule that checks if a variable's value is in a list of specified values. It can also check if the value is not in the list if the negative parameter is set to True. The class generates an SQL expression based on the input parameters and provides methods to access the expression, name, description, subtype_comparison, list of values, and the affected variable.Methods:__init__: Initializes the InValuesRule object with a Variable object, a list of values, and a boolean flag to indicate if the rule should check for values not in the list.get_structure: Returns a dictionary with the expression, name, and description of the rule.Example:fromcdmbimportVariablefromcdmbimportInValuesRulevariable_1=Variable('sex_cd',"patient's sex")rule=InValuesRule(variable_1,['1','2','3','9'])# rule -> sex_cd IN ('1','2','3','9')rule2=InValuesRule(variable_1,['1','2','3','9'],negative=True)# rule2 ->  sex_cd NOT IN ('1','2','3','9')ComposedRuleMain functionalities:The ComposedRule class is a subclass of the abstract class Rule and represents a complex rule that combines two other rules using a logical operator (and/or). It allows the creation of more complex rules by combining simpler rules.Methods:__init__: Constructor that initializes the ComposedRule object with two Rule objects and a logical operator to combine them.get_structure: Returns a dictionary with the expression, name, and description of the composed rule.Example:fromcdmbimportVariablefromcdmbimportComposedRule,ComparisonRulevariable_1=Variable('sex_cd',"patient's sex")variable_2=Variable('pregnancy_bl',"pregnancy status")composed_rule=ComposedRule(left_statement=ComparisonRule(variable_1,'=','1'),logical_operator='and',## and | orright_statement=ComparisonRule(variable_2,'!=',False))# composed_rule -> (sex_cd = 1) and (pregnancy_bl != FALSE)DummyRuleMain functionalities:The DummyRule class is a subclass of the abstract Rule class and is used to create a dummy rule with a custom expression, name, and description. This class can be used to create a rule that does not fit into any of the other rule subclasses.
Exploit the full potential of DuckDB by following itsdocumentation.Methods:__init__: Initializes the DummyRule object with the given expression, name, and description.get_structure: Returns a dictionary with the expression, name, and description of the rule.Example:fromcdmbimportDummyRuler1=DummyRule(expression="diagnose LIKE 'I20%' and age_cd < 40",name='heart attacks rule',description=' heart attacks in people under 40 years of age')# r1 -> diagnose LIKE 'I20%' and age_cd < 40RelationshipsMain functionalities:The Relationship class represents the relationship between two entities (Entity) and provides functionalities to establish and update the relationship. It allows the user to specify the left and right entities, the left and right columns, and the type of join. It also provides methods to get the structure of the relationship and to update the left and right entities, columns, and join type.Methods:__init__: Initializes the Relationship object with the left and right entities, left and right columns, and join type.get_structure: Returns a dictionary with the structure of the relationship.Fields:left_entity: The left entity of the relationship.right_entity: The right entity of the relationship.join_type: The type of join between the two entities.left_column: The left column of the relationship.right_column: The right column of the relationship.Example:fromcdmbimportEntityfromcdmbimportVariablefromcdmbimportRelationshipmain_entity=Entity(name='Admission',time_varying=False,variables=[Variable('patient_id',"Patient's pseudonymized id"),Variable('service_cd',"Service's code")])services_entity=Entity(name='Service',time_varying=False,variables=[Variable('code',"Service's code"),Variable('description',"Service's description")])relationship=Relationship(left_entity=main_entity,right_entity=services_entity,left_column=Variable('service_cd',"Service's code"),right_column=Variable('code',"Service's code"),join_type="LEFT JOIN"# Join Options -> ["LEFT JOIN", "INNER JOIN", "RIGHT JOIN", "FULL JOIN"])Common Data ModelMain functionalities:The CommonDataModel class represents a common data model that can be used to define metadata, cohorts, entities, and relationships in a data project.It provides methods to add and remove entities, set and get metadata and cohort information, and save the project to a specified directory.It also has a method to generate a JSON structure representing the data model and a method to load a previous configuration from a dictionary or from web files.Methods:__init__: Initializes the CommonDataModel object with metadata, cohort, entities, and relationships.add_entity: Adds an entity to the list of entities.pop_entity: Removes and returns the last entity from the list of entities.save_project: Saves the project to a specified directory by calling various private methods to write metadata, cohort, entities, relationships, and other project files.save_zipped_project: Saves the project to a temporary directory, creates a zip file of the project, and returns the UUID of the zip file.generate_json_structure: Generates a JSON structure representing the data model.load_previous_configuration: Loads a previous configuration from a dictionary and returns the metadata, cohort, entities, and relationships.get_er: Generates an entity-relationship diagram (ER diagram) for the entities and relationships.Example:fromcdmbimportMetadatafromcdmbimportAuthorfromcdmbimportCohortfromcdmbimportEntityfromcdmbimportVariablefromcdmbimportRelationshipimportdatetimefromcdmb.CommonDataModelimportCommonDataModelmetadata=Metadata(project='Test Project',use_case='Use Case')author=Author(name='John Doe',affiliation='University of California',id='0000-0000-0000-0001')metadata=Metadata(project='Test Project',use_case='Use Case')metadata.add_author(author)cohort=Cohort(name='Cohort name',description='Cohort description',inclusion_criteria='Inclusion criteria text',beggining_study_period=datetime.date(2021,1,1),end_study_period=datetime.date(2021,12,31))main_entity=Entity(name='Admission',time_varying=False,variables=[Variable('patient_id',"Patient's pseudonymized id"),Variable('service_cd',"Service's code")])services_entity=Entity(name='Service',time_varying=False,variables=[Variable('code',"Service's code"),Variable('description',"Service's description")])rel=Relationship(left_entity=main_entity,right_entity=services_entity,left_column=Variable('service_cd',"Service's code"),right_column=Variable('code',"Service's code"),join_type="LEFT JOIN"# Join Options -> ["LEFT JOIN", "INNER JOIN", "RIGHT JOIN", "FULL JOIN"])cdmb_=CommonDataModel(metadata_definition=metadata,cohort_definition=cohort,entities=[main_entity,services_entity],relationships=[rel])cdmb_.save_project(out_dir='outputs')# save folder structurecdmb_.save_zipped_project(out_dir='outputs')# save zipData typesSeveral data types are used to restrict the values that can take certain variables or parameters.
For example:NatureOptions: is a data type that can only take the values "Condition", "Intervention", "Drugs" or "Any".FormatOptions: is a data type that can only take the values "String", "Boolean", "Date", "Datetime", "Integer" or "Double".TypeOptions: is a data type that can only take the values "Categorical", "Date" or "Numerical".RequirementOptions: is a data type that can only take the values "Required", "Recommended" or "Optional".JoinOptions: is a data type that can only take the values "LEFT JOIN", "INNER JOIN", "RIGHT JOIN" or "FULL JOIN".CharacteristicOptions: is a data type that can only take the values "Observed" or "Calculated".ComparisonOperators: is a data type that can only take the values '<', '<=', '>', '>=', '=', '<>', '!='.BooleanOperators: is a data type that can only take the values 'and' or 'or'.AuthoringCommon Data Model Builder (cdmb) has been developed by theData Science for Health Services and Policy research groupin the Institute for Health Sciences in Aragón (IACS).Lead byJavier González-Galindo, with the colaboration ofFrancisco Estupiñán-Romero,
andSantiago Royo-Sierra, under the supervision and coordination ofEnrique Bernal-Delgado(PI).How to contributeRepository:https://github.com/cienciadedatosysalud/cdmb/Issue tracker:https://github.com/cienciadedatosysalud/cdmb/issuesTranslate Common Data Model Builder (cdmb) to your languageCDMB useshttps://github.com/kaisermann/svelte-i18nfor internationalization.Currently 'cdmb' supports English (by default) and Spanish. Language selection is based on the default language set in your browser.You can contribute adding another language. If you are interested in having the tool in your language, please contact us through the following link:Contact usReferencesData Science for Health Services and Policy Research group:https://cienciadedatosysalud.org/en/Atlas VPM Community:https://zenodo.org/communities/atlasvpmORCID:https://orcid.org/